org.springframework.web.util.pattern

Class InternalPathPatternParser

java.lang.Object

org.springframework.web.util.pattern.InternalPathPatternParser

class InternalPathPatternParser
extends java.lang.Object

Parser for URI template patterns. It breaks the path pattern into a number of PathElements in a linked list. Instances are reusable but are not thread-safe.

Since:

5.0

Author:

Andy Clement

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.List<java.lang.String>	capturedVariableNames
private PathElement	currentPE
private PathElement	headPE
private boolean	insideVariableCapture
private boolean	isCaptureTheRestVariable
private PathPatternParser	parser
private int	pathElementStart
private char[]	pathPatternData
private int	pathPatternLength
(package private) int	pos
private int	singleCharWildcardCount
private int	variableCaptureCount
private int	variableCaptureStart
private boolean	wildcard

Constructor Summary

Constructors

Constructor and Description
InternalPathPatternParser(PathPatternParser parentParser) Package private constructor for use in PathPatternParser.parse(java.lang.String).

Method Summary

Modifier and Type	Method and Description
private PathElement	createPathElement() Used the knowledge built up whilst processing since the last path element to determine what kind of path element to create.
private int	findRegexStart(char[] data, int offset) For a path element representing a captured variable, locate the constraint pattern.
private char[]	getPathElementText()
PathPattern	parse(java.lang.String pathPattern) Package private delegate for PathPatternParser.parse(String).
private boolean	peekDoubleWildcard() After processing a separator, a quick peek whether it is followed by ** (and only ** before the end of the pattern or the next separator)
private void	pushPathElement(PathElement newPathElement)
private void	recordCapturedVariable(int pos, java.lang.String variableName) Record a new captured variable.
private void	resetPathElementState() Reset all the flags and position markers computed during path element processing.
private void	skipCaptureRegex() Just hit a ':' and want to jump over the regex specification for this variable.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

parser

private final PathPatternParser parser

pathPatternData

private char[] pathPatternData

pathPatternLength

private int pathPatternLength

pos

int pos

singleCharWildcardCount

private int singleCharWildcardCount

wildcard

private boolean wildcard

isCaptureTheRestVariable

private boolean isCaptureTheRestVariable

insideVariableCapture

private boolean insideVariableCapture

variableCaptureCount

private int variableCaptureCount

pathElementStart

private int pathElementStart

variableCaptureStart

private int variableCaptureStart

capturedVariableNames

@Nullable
private java.util.List<java.lang.String> capturedVariableNames

headPE

@Nullable
private PathElement headPE

currentPE

@Nullable
private PathElement currentPE

Constructor Detail

InternalPathPatternParser

InternalPathPatternParser(PathPatternParser parentParser)

Package private constructor for use in PathPatternParser.parse(java.lang.String).

Parameters:

parentParser - reference back to the stateless, public parser

Method Detail

parse

public PathPattern parse(java.lang.String pathPattern)
                  throws PatternParseException

Package private delegate for PathPatternParser.parse(String).

Throws:

PatternParseException

skipCaptureRegex

private void skipCaptureRegex()

Just hit a ':' and want to jump over the regex specification for this variable. pos will be pointing at the ':', we want to skip until the }.

Nested {...} pairs don't have to be escaped: /abc/{var:x{1,2}}/def

An escaped } will not be treated as the end of the regex: /abc/{var:x\\{y:}/def

A separator that should not indicate the end of the regex can be escaped:

peekDoubleWildcard

private boolean peekDoubleWildcard()

After processing a separator, a quick peek whether it is followed by ** (and only ** before the end of the pattern or the next separator)

pushPathElement

private void pushPathElement(PathElement newPathElement)

Parameters:

newPathElement - the new path element to add to the chain being built

getPathElementText

private char[] getPathElementText()

createPathElement

private PathElement createPathElement()

Used the knowledge built up whilst processing since the last path element to determine what kind of path element to create.

Returns:

the new path element

findRegexStart

private int findRegexStart(char[] data,
                           int offset)

For a path element representing a captured variable, locate the constraint pattern. Assumes there is a constraint pattern.

Parameters:

data - a complete path expression, e.g. /aaa/bbb/{ccc:...}

offset - the start of the capture pattern of interest

Returns:

the index of the character after the ':' within the pattern expression relative to the start of the whole expression

resetPathElementState

private void resetPathElementState()

Reset all the flags and position markers computed during path element processing.

recordCapturedVariable

private void recordCapturedVariable(int pos,
                                    java.lang.String variableName)

Record a new captured variable. If it clashes with an existing one then report an error.